﻿using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;

namespace CommonAdmin.Util
{
    public class Tools
    {
        /// <summary>
        /// 生成指定长度的随机字符串
        /// (包含数字+大小写字母,不包含特殊符号)
        /// </summary>
        /// <param name="intLength">随机字符串长度</param>
        /// <returns>字符串长度，包含数字t,包含符号f，包含小写字母t，包含大写字母t</returns>
        public static string GetRandomizer(int intLength)
        {
            return GetRandomizer(intLength, true, false, true, true);//字符串长度，包含数字t,包含符号f，包含小写字母t，包含大写字母t
        }
        /// <summary>
        /// 生成指定长度的随机字符串
        /// </summary>
        /// <param name="intLength">随机字符串长度</param>
        /// <param name="booNumber">生成的字符串中是否包含数字</param>
        /// <param name="booSign">生成的字符串中是否包含符号</param>
        /// <param name="booSmallword">生成的字符串中是否包含小写字母</param>
        /// <param name="booBigword">生成的字符串中是否包含大写字母</param>
        /// <returns></returns>
        private static string GetRandomizer(int intLength, bool booNumber, bool booSign, bool booSmallword, bool booBigword)
        {
            //定义  
            Random ranA = new Random();
            int intResultRound = 0;
            int intA = 0;
            string strB = "";

            while (intResultRound < intLength)
            {
                //生成随机数A，表示生成类型  
                //1=数字，2=符号，3=小写字母，4=大写字母  

                intA = ranA.Next(1, 5);

                //如果随机数A=1，则运行生成数字  
                //生成随机数A，范围在0-10  
                //把随机数A，转成字符  
                //生成完，位数+1，字符串累加，结束本次循环  

                if (intA == 1 && booNumber)
                {
                    intA = ranA.Next(0, 10);
                    strB = intA.ToString() + strB;
                    intResultRound = intResultRound + 1;
                    continue;
                }

                //如果随机数A=2，则运行生成符号  
                //生成随机数A，表示生成值域  
                //1：33-47值域，2：58-64值域，3：91-96值域，4：123-126值域  

                if (intA == 2 && booSign == true)
                {
                    intA = ranA.Next(1, 5);

                    //如果A=1  
                    //生成随机数A，33-47的Ascii码  
                    //把随机数A，转成字符  
                    //生成完，位数+1，字符串累加，结束本次循环  

                    if (intA == 1)
                    {
                        intA = ranA.Next(33, 48);
                        strB = ((char)intA).ToString() + strB;
                        intResultRound = intResultRound + 1;
                        continue;
                    }

                    //如果A=2  
                    //生成随机数A，58-64的Ascii码  
                    //把随机数A，转成字符  
                    //生成完，位数+1，字符串累加，结束本次循环  

                    if (intA == 2)
                    {
                        intA = ranA.Next(58, 65);
                        strB = ((char)intA).ToString() + strB;
                        intResultRound = intResultRound + 1;
                        continue;
                    }

                    //如果A=3  
                    //生成随机数A，91-96的Ascii码  
                    //把随机数A，转成字符  
                    //生成完，位数+1，字符串累加，结束本次循环  

                    if (intA == 3)
                    {
                        intA = ranA.Next(91, 97);
                        strB = ((char)intA).ToString() + strB;
                        intResultRound = intResultRound + 1;
                        continue;
                    }

                    //如果A=4  
                    //生成随机数A，123-126的Ascii码  
                    //把随机数A，转成字符  
                    //生成完，位数+1，字符串累加，结束本次循环  

                    if (intA == 4)
                    {
                        intA = ranA.Next(123, 127);
                        strB = ((char)intA).ToString() + strB;
                        intResultRound = intResultRound + 1;
                        continue;
                    }

                }

                //如果随机数A=3，则运行生成小写字母  
                //生成随机数A，范围在97-122  
                //把随机数A，转成字符  
                //生成完，位数+1，字符串累加，结束本次循环  

                if (intA == 3 && booSmallword == true)
                {
                    intA = ranA.Next(97, 123);
                    strB = ((char)intA).ToString() + strB;
                    intResultRound = intResultRound + 1;
                    continue;
                }

                //如果随机数A=4，则运行生成大写字母  
                //生成随机数A，范围在65-90  
                //把随机数A，转成字符  
                //生成完，位数+1，字符串累加，结束本次循环  

                if (intA == 4 && booBigword == true)
                {
                    intA = ranA.Next(65, 89);
                    strB = ((char)intA).ToString() + strB;
                    intResultRound = intResultRound + 1;
                    continue;
                }
            }
            return strB;

        }

        /// <summary>
        /// MD5加密
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public static string EncryptByMD5(string text)
        {
            using (MD5 md5 = MD5.Create())
            {
                byte[] data = md5.ComputeHash(Encoding.UTF8.GetBytes(text));
                return Convert.ToBase64String(data);
            }
        }
        public static string NewGuid()
        {
            return Guid.NewGuid().ToString("N");
        }
		/// <summary>
		///获取枚举Description中显示内容
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <returns></returns>
		public static IList<KeyValuePair<string, string>> GetEnumDisplayNames<T>()
		{
			Type type = typeof(T);
			List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();
			foreach (string name in Enum.GetNames(type))
			{
				DescriptionAttribute customAttribute = type.GetField(name).GetCustomAttribute<DescriptionAttribute>();
				if (customAttribute == null)
				{
					list.Add(new KeyValuePair<string, string>(name, name));
				}
				else
				{
					list.Add(new KeyValuePair<string, string>(name, customAttribute.Description));
				}
			}
			return list;
		}
		public static string GetEnumDescription(Enum enumValue)
		{
			string value = enumValue.ToString();
			FieldInfo field = enumValue.GetType().GetField(value);
			object[] objs = field.GetCustomAttributes(typeof(DescriptionAttribute), false);    //获取描述属性
			if (objs == null || objs.Length == 0)    //当描述属性没有时，直接返回名称
				return value;
			DescriptionAttribute descriptionAttribute = (DescriptionAttribute)objs[0];
			return descriptionAttribute.Description;
		}
        
	}
}
